package cn.bby.tools.utils;

import cn.hutool.core.codec.Base64;
import cn.hutool.core.util.ZipUtil;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

/**
 * 字节与字符串转换工具类
 * 提供多种将byte[]转换为字符串的方式，以实现最小空间占用
 *
 * @author assistant
 */
public class ByteStringUtil {

    /**
     * 将字符串以最小占用方式压缩并转换为字符串
     * 使用ZipUtil.zlib压缩后将每两个byte组装成一个char，实现最小空间占用
     *
     * @param str 字符串
     * @return 压缩后编码的字符串
     */
    public static String compressMinimize(String str) {
        if (str == null || str.isEmpty()) {
            return "";
        }

        // 使用UTF-8编码将字符串转换为字节数组
        byte[] originalBytes = str.getBytes(StandardCharsets.UTF_8);
        
        // 使用ZipUtil进行压缩，压缩级别为9（最佳压缩比）
        byte[] compressedBytes = ZipUtil.zlib(originalBytes, 9);
        
        // 将每两个byte组装成一个char
        return bytesToChars(compressedBytes);
    }

    /**
     * 将最小占用字符串还原为原始字符串
     *
     * @param compressedStr 压缩编码后的字符串
     * @return 原始字符串
     */
    public static String decompressMinimize(String compressedStr) {
        if (compressedStr == null || compressedStr.isEmpty()) {
            return "";
        }

        try {
            // 将char还原为byte[]
            byte[] compressedBytes =charsToBytes(compressedStr);
            
            // 使用ZipUtil解压缩
            byte[] originalBytes = ZipUtil.unZlib(compressedBytes);
            
            // 使用UTF-8解码为字符串
            return new String(originalBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            // 如果解码失败，返回空字符串
            return "";
        }
    }
    /**
     * 将byte数组转换为char字符串
     * 每两个byte组成一个char
     *
     * @param bytes 字节数组
     * @return char组成的字符串
     */
    private static String bytesToChars(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return "";
        }
        return new String(bytes, StandardCharsets.ISO_8859_1);
//        // 计算需要的char数量
//        int charCount = (bytes.length + 1) / 2;
//        char[] chars = new char[charCount];
//
//        for (int i = 0; i < bytes.length; i += 2) {
//            // 第一个byte放在高8位
//            int first = bytes[i] & 0xFF;
//            // 第二个byte放在低8位，如果是最后一个byte且数组长度为奇数，则低8位为0
//            int second = (i + 1 < bytes.length) ? bytes[i + 1] & 0xFF : 0;
//            // 组合成char
//            chars[i / 2] = (char) ((first << 8) | second);
//        }
//
//        return new String(chars);
    }
    
    /**
     * 将char字符串转换为byte数组
     * 每个char拆分为两个byte
     * 
     * @param str char组成的字符串
     * @return 字节数组
     */
    private static byte[] charsToBytes(String str) {
        if (str == null || str.isEmpty()) {
            return new byte[0];
        }
        return str.getBytes(StandardCharsets.ISO_8859_1);
//        char[] chars = str.toCharArray();
//        // 计算byte数组长度
//        int byteCount = chars.length * 2;
//        byte[] bytes = new byte[byteCount];
//
//        for (int i = 0; i < chars.length; i++) {
//            // 高8位作为第一个byte
//            bytes[i * 2] = (byte) ((chars[i] >> 8) & 0xFF);
//            // 低8位作为第二个byte
//            bytes[i * 2 + 1] = (byte) (chars[i] & 0xFF);
//        }
//
//        return bytes;
    }
}